﻿/********************************************************************************************
 * Time de desenvolvedores
 *  Vinícius Batista de Souza       @vbs_br
 *  Fermando Martin Figuera         @fernandomartin
 *  
 *  
 * Jogo desenvolvido para testar algumas features e produzir trilha de treinamento no MSDN.
 * Faça o download do SDK do Windows Phone, faça você também o seu jogo :)
 * 
 * Dúvidas utilizem o Forúm do Windows Phone no MSDN.
********************************************************************************************/



using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Media;
using Microsoft.Phone.Controls;
using System.Windows.Threading;
using System.Windows.Media.Imaging;
using System.IO;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework;
using Microsoft.Devices.Radio;

namespace ComboBUG
{
    /// <summary>
    /// Classe responsáel pelo jogo em si.
    /// </summary>
    public partial class GamePage : PhoneApplicationPage
    {

        //Timer para animação dos Bug's
        DispatcherTimer timer_image_animation = new DispatcherTimer();
        //Timer para dar uma pausa antes de redirecionar o usuário para a página de GameOver
        DispatcherTimer timer_gameover = new DispatcherTimer();
        static Random random = new Random();

        private int qtde_elementos_inseridos_no_wrapPanel;

        List<UserControlElemento> listagemElementos_paraRemover;

        int tamanho_userControl = 85;

        double wrap_w = 595;
        double wrap_h = 425;

        int pontuacao = 0;
        
        int count_itens_removidos = 0; //  guarda quantos itens foram removidos 

        int ic_nivel = 1;

        public int contador_recursividade = 0;

        double vl_linha_layoutRoot_1_portrait = 0.00;
        double vl_linha_layoutRoot_2_portrait = 640.00;
        double vl_linha_layoutRoot_3_portrait = 160.00;
        double vl_linha_layoutRoot_1_landscape = 0.00;
        double vl_linha_layoutRoot_2_landscape = 0.00;
        double vl_linha_layoutRoot_3_landscape = 0.00;


        int Numero_de_BUG_para_adicionar = 0;

        //Storyboard _ambiente;


        #region GamePage
        // Constructor
        public GamePage()
        {
            InitializeComponent();

            ///Registro dos eventos 
            Loaded += new RoutedEventHandler(MainPage_Loaded);
            btRestart.Click += new RoutedEventHandler(btRestart_Click);

        }
        #endregion

        #region MainPage_Loaded
        void MainPage_Loaded(object sender, RoutedEventArgs e)
        {

            //Registrando o evento de timer
            //Realiza a alteração das imagens durante o jogo.
            timer_image_animation.Interval = TimeSpan.FromMilliseconds(250);
            timer_image_animation.Tick += new EventHandler(timer_image_animation_Tick);
            timer_image_animation.Start();

            //Registrando o timer para o game over.
            timer_gameover.Interval = TimeSpan.FromMilliseconds(2000);
            timer_gameover.Tick += new EventHandler(timer_gameover_Tick);

            ic_nivel = 1;
            Nivel(ic_nivel);
            txtNivel.Text = ic_nivel.ToString();

        }
        #endregion

        #region Nivel
        private void Nivel(int nivel)
        {
            //Se quiser pode alterar para adicionar bugs de acordo com o nível.
            Numero_de_BUG_para_adicionar = 35;

            txtEspecial.Text = string.Empty;

            //Atualizar o label de nível
            txtNivel.Text = ic_nivel.ToString();

            qtde_elementos_inseridos_no_wrapPanel = Numero_de_BUG_para_adicionar;


            //calcular o tamanho dos bugs em função da quantidade a ser inserida.
            double size = Helper.SetBugSize(qtde_elementos_inseridos_no_wrapPanel, wrap_w, wrap_h);

            for (int i = 0; i <= qtde_elementos_inseridos_no_wrapPanel - 1; i++)
            {
                WrapPanelPrincipal.Children.Add(CreateUC(nivel, 0, size));
            }


            listagemElementos_paraRemover = new List<UserControlElemento>();

            BitmapImage bmp = new BitmapImage(new Uri("/ComboBUG;component/Media/Images/fundo3.jpg"));

        }
        #endregion

        #region NiveisFases


        private int RetornaNumeroAleatorioNilvel(int level)
        {
            int numUC = 0;

            if (level == 1) { numUC = 3; }
            if (level == 2) { numUC = 4; }
            if (level == 3) { numUC = 5; }
            if (level == 4) { numUC = 6; }
            if (level == 5) { numUC = 7; }
            if (level == 6) { numUC = 8; }
            if (level == 7) { numUC = 9; }
            if (level == 8) { numUC = 10; }

            return RandomNumber(1, numUC); //ele nao pega o 8 mas pega o 1

        }


        private UserControlElemento CreateUC(int level, int numero_imagem, double size_elemento)
        {

            int numUC = 0;

            if (level == 1) { numUC = 3; }
            if (level == 2) { numUC = 4; }
            if (level == 3) { numUC = 5; }
            if (level == 4) { numUC = 6; }
            if (level == 5) { numUC = 7; }
            if (level == 6) { numUC = 8; }
            if (level == 7) { numUC = 9; }
            if (level == 8) { numUC = 10; }

            UserControlElemento UCe = new UserControlElemento();

            int numero;

            if (numero_imagem == 0)
            {
                numero = RandomNumber(1, numUC); //ele nao pega o 8 mas pega o 1
            }
            else
            {
                numero = RandomNumber(numero_imagem, numero_imagem); //ele nao pega o primeiro mas pega o 1
            }

            UCe.SetTAG(numero);
            UCe.TrocaImagem(numero, size_elemento);
            UCe.Height = size_elemento; // tamanho_userControl;
            UCe.Width = size_elemento; // altura_userControl;
            return UCe;
        }

        #endregion

        #region _timer_Tick
        void timer_image_animation_Tick(object sender, EventArgs e)
        {
            AleatorioImagem();
        }
        #endregion

        #region RandomNumber
        private int RandomNumber(int min, int max)
        {
            if (max < 1) { return 1; }

            return random.Next(min, max);
        }
        #endregion

        #region Reseta_numeros_removidos
        public void Reseta_numeros_removidos()
        {
            this.count_itens_removidos = 0;
        }
        #endregion

        #region PlayBeep
        private void PlayBeep(int ic_play)
        {
            if (Microsoft.Xna.Framework.Media.MediaPlayer.State != MediaState.Playing && 
                ( FMRadio.Instance.PowerMode != RadioPowerMode.On))
            {
                try
                {

                    String _play = "Media/audio/ok.wav";

                    if (ic_play == 1)
                    {
                        _play = "Media/audio/one.wav";
                    }
                    else if (ic_play == 2)
                    {
                        _play = "Media/audio/two.wav";
                    }
                    else if (ic_play == 3)
                    {
                        _play = "Media/audio/ten.wav";
                    }
                    else if (ic_play == 4) //Erro
                    {
                        _play = "Media/audio/erro.wav";
                    }
                    else if (ic_play == 5) //GameOver
                    {
                        _play = "Media/audio/GameOver.wav";
                    }

                    Stream stream = TitleContainer.OpenStream(_play);
                    SoundEffect soundEffect = SoundEffect.FromStream(stream);
                    soundEffect.Play();

                }
                catch (InvalidOperationException ex)
                {
                    MessageBox.Show("ERRO:" + ex.ToString());
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
            }

        }
        #endregion

        #region MudaFase
        /// <summary>
        /// Verifica se o usuário chegou no nível máximo do jogo
        /// </summary>
        /// <param name="restart"></param>
        public void MudaFase(bool restart)
        {


            if (WrapPanelPrincipal.Children.Count == 0)
            {

                if (restart == false)
                {
                    ic_nivel++;
                }


                if (ic_nivel == 8)
                {
                    NavigationService.Navigate(new Uri(
                    string.Format("/EndOfGame.xaml"), UriKind.Relative));
                    return;
                }

                Nivel(ic_nivel);

                txtNivel.Text = ic_nivel.ToString();


            }


        }
        #endregion

        #region TotalizaResultados
        public void TotalizaResultados()
        {
            if (count_itens_removidos > 0)
            {
                txtPontos.Text = FormataZerosPontos(pontuacao.ToString());
                Reseta_numeros_removidos();
            }
        }
        #endregion

        #region ProcuraElementosParaRemover
        /// <summary>
        /// Classe principal responsável pela mecânica de combo das cores.
        /// 
        /// Dado o bug que foi clicado essa função recursiva busca por bugs com a mesma cor para serem removidos. Realizando o combo.
        /// </summary>
        /// <param name="bug"></param>
        public void ProcuraElementosParaRemover(UserControlElemento bug)
        {
            //Só executa o algoritmo se o bug for diferente de null e não estiver na lista de bugs para remover.
            //Ponto de saída do método recursivo
            if (bug != null && !listagemElementos_paraRemover.Contains(bug))
            {
                //Variávies de controle
                int index_bug = -1;
                double number_bug_per_line = 0;
                double number_bug_per_column = 0;
                double number_bugs_total = 0;
                double position = 0;
                double actual_lines = 0;
                int index_bug_up, index_bug_down, index_bug_lef, index_bug_right;

                UserControlElemento bug_up = null;
                UserControlElemento bug_down = null;
                UserControlElemento bug_right = null;
                UserControlElemento bug_left = null;

                index_bug_up = index_bug_down = index_bug_lef = index_bug_right = -1;

                //Recuperando o index do bug no wrapPanel
                index_bug = WrapPanelPrincipal.Children.IndexOf(bug);

                //Atualizando números de bugs
                //Para realizar o cálculo de discover do bugs em função do bug clicado, tenho que saber quantos bug há por linha.
                number_bug_per_line = WrapPanelPrincipal.ActualWidth / bug.ActualWidth;
                number_bug_per_column = (WrapPanelPrincipal.ActualHeight / bug.ActualHeight) - 1;
                number_bugs_total = number_bug_per_line * number_bug_per_column;
                actual_lines = Math.Ceiling(WrapPanelPrincipal.Children.Count / number_bug_per_line);

                //Calculando a posição do bug no Wrap
                position = index_bug / number_bug_per_line;

                //Adiciona os objetos que serão removidos em uma lista.
                listagemElementos_paraRemover.Add(bug);

                //recuperando o index do bug logo acima do bug do parâmetro
                //Primeiro verificar se o bug não está na primeira linha
                if (Helper.GetLineBug(position) != 1)
                {
                    index_bug_up = index_bug - (int)number_bug_per_line;
                }

                //recuperando o index do bug logo abaixo do bug do parâmetro
                //Primeiro verificar se o bug não está na última linha
                if (Helper.GetLineBug(position) != Math.Floor(actual_lines))
                {
                    index_bug_down = index_bug + (int)number_bug_per_line;
                    if (index_bug_down > WrapPanelPrincipal.Children.Count - 1)
                        index_bug_down = -1;
                }

                //recuperando o index do Bug do lado direito
                //Verificar se não clicou no último Bug
                if (Helper.GetColumnBug(position, number_bug_per_line) != number_bug_per_line &&
                    WrapPanelPrincipal.Children.Count - 1 != index_bug)
                {
                    index_bug_right = index_bug + 1;
                    if (index_bug_right > WrapPanelPrincipal.Children.Count - 1)
                        index_bug_right = -1;
                }

                //recuperando o index do Bug do lado esquerdo
                //Verifica se não foi clicado o primeiro bug da linha
                if (Helper.GetColumnBug(position, number_bug_per_line) != 1)
                {
                    index_bug_lef = index_bug - 1;
                }

                //verifica se o index de cada bug é igual a -1, se for atualiza a referencia de cada bug para null
                bug_up = index_bug_up != -1 ? WrapPanelPrincipal.Children[index_bug_up] as UserControlElemento : null;
                bug_down = index_bug_down != -1 ? WrapPanelPrincipal.Children[index_bug_down] as UserControlElemento : null;
                bug_right = index_bug_right != -1 ? WrapPanelPrincipal.Children[index_bug_right] as UserControlElemento : null;
                bug_left = index_bug_lef != -1 ? WrapPanelPrincipal.Children[index_bug_lef] as UserControlElemento : null;

                //verificar se deve seguir adiante nos bugs adicionados.
                //Somente executar o algoritmo se o bug for da mesma cor, verificar em todas as posições.
                if (bug_up != null && bug_up.EhIgual(bug.GetTAG().ToString()))
                    ProcuraElementosParaRemover(bug_up);

                if (bug_down != null && bug_down.EhIgual(bug.GetTAG().ToString()))
                    ProcuraElementosParaRemover(bug_down);

                if (bug_right != null && bug_right.EhIgual(bug.GetTAG().ToString()))
                    ProcuraElementosParaRemover(bug_right);

                if (bug_left != null && bug_left.EhIgual(bug.GetTAG().ToString()))
                    ProcuraElementosParaRemover(bug_left);

            }

            //Para fins de teste deixei um contador de recursividade, que conta quantas vezes a função foi executada para cada bug clicado.
            contador_recursividade++;


        }
        #endregion

        #region VerificaElementos
        /// <summary>
        /// Verifica se existem bugs suficientes para realizar um combo caso contrário dá play de som de erro.
        /// 
        /// </summary>
        public void VerificaElementos()
        {

            UserControlElemento uce_primeiro = null;

            count_itens_removidos = listagemElementos_paraRemover.Count;

            //Verificar se existe pelo menos um bug a ser removido
            if (listagemElementos_paraRemover.Count > 1)
            {
                uce_primeiro = (UserControlElemento)listagemElementos_paraRemover[0];
                
                //Libera o clique nos combos
                if (uce_primeiro != null)
                {
                    uce_primeiro.LiberaClick();
                }


                //Atualiza a pontuação do jogo e toca sons de acordo com a pontuação.
                AtualizaPontuacao();

                //Remove os bugs do Wrap
                RemoveBugsWrap();

                //Verifica se é necessário aumentar o nível do jogo ou se já deu GameOver.
                ContinuaJogo();

                //Atualiza o placar do jogo
                TotalizaResultados();
            }
            else
            {
                //Se o bug que o usuário clicou não possui vizinhos iguais dá play de mensagem de erro.
                PlayBeep(4);
                UserControlElemento uce = (UserControlElemento)listagemElementos_paraRemover[0];
                if (uce != null)
                    uce.LiberaClick();
            }

            //Limpa a lista de bugs 
            listagemElementos_paraRemover.Clear();

        }
        #endregion

        #region time_gameover_Tick
        /// <summary>
        /// Evento disparado quando for dectado o gameover
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void timer_gameover_Tick(object sender, EventArgs e)
        {
            //Exemplo de navegação com passagem de parâmetros, utiliza notação de URL
            NavigationService.Navigate(new Uri(string.Format("/GameOver.xaml?score={0}&level={1}", pontuacao, ic_nivel), UriKind.Relative));
            timer_gameover.Stop();
        }
        #endregion

        #region ContinuaJogo
        /// <summary>
        /// O Método verifica se o usuário passou da fase atual.
        /// 
        /// Para cada Bug existente, o método verifica se existe a possibilidade de realizar um combo. 
        /// O processamento é penoso, pois é executado o algoritmo recursivo para remoção dos bugs para todos os bugs existentes.
        /// 
        /// </summary>
        private void ContinuaJogo()
        {
            bool gameover = false;
            if (WrapPanelPrincipal.Children.Count == 0)
            {
                //Incrementa prpriedade de fase
                ic_nivel++;

                //Atualizar a propriedade de nível máxima, verificação interna ao helper
                Helper.SetMaxLevel(ic_nivel);

                //Verifica se a quantidade máxima de fases foi atingida
                if (ic_nivel == 8)
                {
                    //Criar uma página nova dando os parabéns para o jogador.
                    //Fazer o redirecionamento para a página de congratulations
                    NavigationService.Navigate(new Uri(string.Format("/EndOfGame.xaml"), UriKind.Relative));
                    return;
                }

                //Realizar os cálculos para a próxima fase
                Nivel(ic_nivel);

            }
            else
            {
                if (WrapPanelPrincipal.Children.Count == 1)
                {
                    gameover = true;
                }
                else
                {
                    //Verificar se é possível selecionar pelo menos um dos bugs para continuar a jogar.
                    if (WrapPanelPrincipal.Children.Count < 20)
                    {
                        bool pode_continuar = false;
                        foreach (UserControlElemento bug in WrapPanelPrincipal.Children)
                        {
                            listagemElementos_paraRemover.Clear();

                            ProcuraElementosParaRemover(bug);

                            if (listagemElementos_paraRemover.Count > 1)
                            {
                                pode_continuar = true;
                                break;
                            }
                        }

                        if (!pode_continuar)
                        {
                            gameover = true;
                            
                        }
                        listagemElementos_paraRemover.Clear();
                    }
                }
            }

            if (gameover)
            {
                PlayBeep(5);
                timer_gameover.Start();
            }
        }
        #endregion

        #region RemoveBugsWrap
        /// <summary>
        /// Remove o elementos de bug do WrapPanelPrincipal
        /// </summary>
        private void RemoveBugsWrap()
        {
            UserControlElemento uce_libera_click = null;

            //Verificar se existe pelo menos um bug a ser removido
            if (count_itens_removidos > 1)
            {
                uce_libera_click = listagemElementos_paraRemover[0] as UserControlElemento;

                for (int i = 0; i <= listagemElementos_paraRemover.Count - 1; i++)
                {
                    WrapPanelPrincipal.Children.Remove(listagemElementos_paraRemover[i]);
                }

            }

            if (uce_libera_click != null)
                uce_libera_click.LiberaClick();
        }
        #endregion

        #region AtualizaPontuacao
        /// <summary>
        /// Realiza o cálculo da pontação de acordo com a quantidade de bugs removidos e o nível que ele se encontra
        /// </summary>
        private void AtualizaPontuacao()
        {
            count_itens_removidos = listagemElementos_paraRemover.Count;

            txtEspecial.Text = "";

            int pontos = 1; //alterei para pontuação de acordo com o nível.


            
            if (ic_nivel == 1)
            {
                //Pontuação
                pontos = count_itens_removidos;
                

                //Efeito Sonoro
                if (count_itens_removidos > 7)
                    PlayBeep(3);
                if (count_itens_removidos == 7)
                    PlayBeep(2);
                else
                    PlayBeep(1);
            }
            else
            {
                //Pontuação
                if (count_itens_removidos > 5)
                    pontos = count_itens_removidos * (5 * (ic_nivel - 1));
                if (count_itens_removidos <= 5 && count_itens_removidos >= 3)
                    pontos = count_itens_removidos * (3 * (ic_nivel - 1));
                if (count_itens_removidos < 3)
                    pontos = count_itens_removidos * (2 * (ic_nivel-1));

                //Efeito Sonoro
                if (count_itens_removidos > 5)
                    PlayBeep(3);
                if (count_itens_removidos <= 5 && count_itens_removidos >= 3)
                    PlayBeep(2);
                else
                    PlayBeep(1);

            }

            pontuacao += pontos;
            txtEspecial.Text = string.Format("Combo {0} : {1} points", count_itens_removidos, pontos);

            //Atualizar a propriedade de pontuação máxima, verificação interna ao helper
            Helper.SetMaxScore(pontuacao);


        }
        #endregion

        #region btRestart_Click
        /// <summary>
        /// Restarta o jogo caso o usuário confirme a mensagem de confirmação.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void btRestart_Click(object sender, RoutedEventArgs e)
        {
            if (MessageBox.Show("Do you want to restart the game?", "Exit", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
            {
                NavigationService.Navigate(new Uri(string.Format("/GamePage.xaml?rand=" + random.Next(int.MaxValue).ToString()), UriKind.Relative));
            }
        }
        #endregion

        #region BackButton

        protected override void OnBackKeyPress(System.ComponentModel.CancelEventArgs e)
        {

            if (MessageBox.Show("Do you really want to exit?", "Exit", MessageBoxButton.OKCancel) == MessageBoxResult.Cancel)
            {
                e.Cancel = true;
            }
            else
            {
                e.Cancel = false;
                NavigationService.Navigate(new Uri(string.Format("/MainPage.xaml"), UriKind.Relative));
            }
        }
        #endregion

        #region AleatorioImagem
        /// <summary>
        /// Realiza a troca randomica das imagens dos Bugs.
        /// </summary>
        private void AleatorioImagem()
        {

            int numeroItensRestantes = WrapPanelPrincipal.Children.Count;

            if (numeroItensRestantes < 0) { return; }

            if (numeroItensRestantes == 1) { numeroItensRestantes = 0; } // tem um bug

            if (numeroItensRestantes == 0) { return; }

            int numAleatorio = RandomNumber(1, numeroItensRestantes);

            UserControlElemento UCe = null;

            try
            {
                UCe = (UserControlElemento)VisualTreeHelper.GetChild(WrapPanelPrincipal, numAleatorio);

            }
            catch (Exception ex)
            {

            }

            if (UCe == null) { return; }


            if (UCe.UC.Tag != null)
            {
                if (UCe.UC.Tag.ToString() == "1")
                {
                    int randImage = random.Next(1, 3);

                    if (randImage == 1)
                    {
                        UCe.TrocaImagem(1);
                    }
                    else
                    {
                        UCe.TrocaImagem(22);
                    }

                }

                if (UCe.UC.Tag.ToString() == "2")
                {
                    int randImage = random.Next(1, 3);

                    if (randImage == 1)
                    {
                        UCe.TrocaImagem(2);
                    }
                    else
                    {
                        UCe.TrocaImagem(32);
                    }

                }

                if (UCe.UC.Tag.ToString() == "3")
                {
                    int randImage = random.Next(1, 3);

                    if (randImage == 1)
                    {
                        UCe.TrocaImagem(3);
                    }
                    else
                    {
                        UCe.TrocaImagem(42);
                    }

                }

                if (UCe.UC.Tag.ToString() == "4")
                {
                    int randImage = random.Next(1, 3);

                    if (randImage == 1)
                    {
                        UCe.TrocaImagem(4);
                    }
                    else
                    {
                        UCe.TrocaImagem(52);
                    }

                }

                if (UCe.UC.Tag.ToString() == "5")
                {
                    int randImage = random.Next(1, 3);

                    if (randImage == 1)
                    {
                        UCe.TrocaImagem(5); //borboleta
                    }
                    else
                    {
                        UCe.TrocaImagem(62);
                    }

                }

                if (UCe.UC.Tag.ToString() == "6")
                {
                    int randImage = random.Next(1, 3);

                    if (randImage == 1)
                    {
                        UCe.TrocaImagem(6); // borboleta
                    }
                    else
                    {
                        UCe.TrocaImagem(72);
                    }

                }

                if (UCe.UC.Tag.ToString() == "7")
                {
                    int randImage = random.Next(1, 3);

                    if (randImage == 1)
                    {
                        UCe.TrocaImagem(7); //larva
                    }
                    else
                    {
                        UCe.TrocaImagem(82);
                    }

                }

                if (UCe.UC.Tag.ToString() == "8")
                {
                    int randImage = random.Next(1, 3);

                    if (randImage == 1)
                    {
                        UCe.TrocaImagem(8);
                    }
                    else
                    {
                        UCe.TrocaImagem(92);
                    }

                }


            }

            //}


        }
        #endregion

        #region PhoneApplicationPage_BeginLayoutChanged
        private void PhoneApplicationPage_BeginLayoutChanged(object sender, OrientationChangedEventArgs e)
        {
            //MessageBox.Show("TROCOU: " + e.ToString() + " " + sender.ToString());

            if (e.Orientation == PageOrientation.LandscapeLeft || e.Orientation == PageOrientation.LandscapeRight)
            {

                vl_linha_layoutRoot_1_landscape = 0.00;
                vl_linha_layoutRoot_2_landscape = 320;
                vl_linha_layoutRoot_3_landscape = 160;


                GridLength t_ = new GridLength(vl_linha_layoutRoot_1_landscape);
                LinhaTop.Height = t_;
                t_ = new GridLength(vl_linha_layoutRoot_2_landscape);
                LinhaMidle.Height = t_;
                t_ = new GridLength(vl_linha_layoutRoot_3_landscape);
                LinhaBottom.Height = t_;


            }
            else if (e.Orientation == PageOrientation.Portrait ||
                     e.Orientation == PageOrientation.PortraitDown ||
                     e.Orientation == PageOrientation.PortraitUp)
            {

                GridLength t_ = new GridLength(vl_linha_layoutRoot_1_portrait);
                LinhaTop.Height = t_;
                t_ = new GridLength(vl_linha_layoutRoot_2_portrait);
                LinhaMidle.Height = t_;
                t_ = new GridLength(vl_linha_layoutRoot_3_portrait);
                LinhaBottom.Height = t_;


            }

        }
        #endregion

        #region FormataZerosPontos
        private string FormataZerosPontos(string valor)
        {
            return string.Format("{0:000000}", int.Parse(valor));

        }
        #endregion


    }













}